home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / CardServices.p < prev    next >
Encoding:
Text File  |  1995-08-23  |  29.0 KB  |  801 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        CardServices.p
  3.  
  4.     Contains:    This file contains constants and data structures that describe
  5.                 the client interface to Card and Socket Services.
  6.  
  7.      Version:    Technology: PCMCIA Software 2.0
  8.                 Package:    Universal Interfaces 2.1.1 in “MPW Latest” on ETO #19
  9.  
  10.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  14.                  stack.  Include the file and version information (from above)
  15.                  in the problem description and send to:
  16.                      Internet:    apple.bugs@applelink.apple.com
  17.                      AppleLink:    APPLE.BUGS
  18.   
  19. }
  20.  
  21. {$IFC UNDEFINED UsingIncludes}
  22. {$SETC UsingIncludes := 0}
  23. {$ENDC}
  24.  
  25. {$IFC NOT UsingIncludes}
  26.  UNIT CardServices;
  27.  INTERFACE
  28. {$ENDC}
  29.  
  30. {$IFC UNDEFINED __CARDSERVICES__}
  31. {$SETC __CARDSERVICES__ := 1}
  32.  
  33. {$I+}
  34. {$SETC CardServicesIncludes := UsingIncludes}
  35. {$SETC UsingIncludes := 1}
  36.  
  37.  
  38. {$IFC UNDEFINED __TYPES__}
  39. {$I Types.p}
  40. {$ENDC}
  41. {    ConditionalMacros.p                                            }
  42.  
  43. {$IFC UNDEFINED __PCCARDTUPLES__}
  44. {$I PCCardTuples.p}
  45. {$ENDC}
  46.  
  47. {$IFC UNDEFINED __MIXEDMODE__}
  48. {$I MixedMode.p}
  49. {$ENDC}
  50.  
  51. {$PUSH}
  52. {$ALIGN MAC68K}
  53. {$LibExport+}
  54.  
  55. CONST
  56.     CS_MAX_SOCKETS                = 32;                            { a long is used as a socket bitmap}
  57.  
  58. { ••• Should eventually move to <Gestalt.h>}
  59.     gestaltCardServicesAttr        = 'pccd';                        { Card Services attributes}
  60.     gestaltCardServicesPresent    = 0;                            { if set, Card Services is present}
  61.  
  62. { ••• Should eventually move to <Traps.h>}
  63.     _PCCardDispatch                = $AAF0;                        { Card Services entry trap}
  64.  
  65. { 
  66.     The PC Card Manager will migrate towards a complete Mac name space very soon.
  67.     Part of that process will be to reassign result codes to a range reserved for
  68.     the PC Card Manager...the range will be...-9050 to -9305 (decimal inclusive).
  69. }
  70. {    result codes}
  71.     kCSBadAdapterErr            = -9050;                        { invalid adapter number}
  72.     kCSBadAttributeErr            = -9051;                        { specified attributes field value is invalid}
  73.     kCSBadBaseErr                = -9052;                        { specified base system memory address is invalid}
  74.     kCSBadEDCErr                = -9053;                        { specified EDC generator specified is invalid}
  75.     kCSBadIRQErr                = -9054;                        { specified IRQ level is invalid}
  76.     kCSBadOffsetErr                = -9055;                        { specified PC card memory array offset is invalid}
  77.     kCSBadPageErr                = -9056;                        { specified page is invalid}
  78.     kCSBadSizeErr                = -9057;                        { specified size is invalid}
  79.     kCSBadSocketErr                = -9058;                        { specified logical or physical socket number is invalid}
  80.     kCSBadTypeErr                = -9059;                        { specified window or interface type is invalid}
  81.     kCSBadVccErr                = -9060;                        { specified Vcc power level index is invalid}
  82.     kCSBadVppErr                = -9061;                        { specified Vpp1 or Vpp2 power level index is invalid}
  83.     kCSBadWindowErr                = -9062;                        { specified window is invalid}
  84.     kCSBadArgLengthErr            = -9063;                        { ArgLength argument is invalid}
  85.     kCSBadArgsErr                = -9064;                        { values in argument packet are invalid}
  86.     kCSBadHandleErr                = -9065;                        { clientHandle is invalid}
  87.     kCSBadCISErr                = -9066;                        { CIS on card is invalid}
  88.     kCSBadSpeedErr                = -9067;                        { specified speed is unavailable}
  89.     kCSReadFailureErr            = -9068;                        { unable to complete read request}
  90.     kCSWriteFailureErr            = -9069;                        { unable to complete write request}
  91.     kCSGeneralFailureErr        = -9070;                        { an undefined error has occurred}
  92.     kCSNoCardErr                = -9071;                        { no PC card in the socket}
  93.     kCSUnsupportedFunctionErr    = -9072;                        { function is not supported by this implementation}
  94.     kCSUnsupportedModeErr        = -9073;                        { mode is not supported}
  95.     kCSBusyErr                    = -9074;                        { unable to process request at this time - try later}
  96.     kCSWriteProtectedErr        = -9075;                        { media is write-protected}
  97.     kCSConfigurationLockedErr    = -9076;                        { a configuration has already been locked}
  98.     kCSInUseErr                    = -9077;                        { requested resource is being used by a client}
  99.     kCSNoMoreItemsErr            = -9078;                        { there are no more of the requested item}
  100.     kCSOutOfResourceErr            = -9079;                        { Card Services has exhausted the resource}
  101.  
  102. {    messages sent to client's event handler}
  103.     kCSNullMessage                = $00;                            { no messages pending (not sent to clients)}
  104.     kCSCardInsertionMessage        = $01;                            { card has been inserted into the socket}
  105.     kCSCardRemovalMessage        = $02;                            { card has been removed from the socket}
  106.     kCSCardLockMessage            = $03;                            { card is locked into the socket with a mechanical latch}
  107.     kCSCardUnlockMessage        = $04;                            { card is no longer locked into the socket}
  108.     kCSCardReadyMessage            = $05;                            { card is ready to be accessed}
  109.     kCSCardResetMessage            = $06;                            { physical reset has completed}
  110.     kCSInsertionRequestMessage    = $07;                            { request to insert a card using insertion motor}
  111.     kCSInsertionCompleteMessage    = $08;                            { insertion motor has finished inserting a card}
  112.     kCSEjectionRequestMessage    = $09;                            { user or other client is requesting a card ejection}
  113.     kCSEjectionFailedMessage    = $0A;                            { eject failure due to electrical/mechanical problems}
  114.     kCSPMResumeMessage            = $0B;                            { power management resume (TBD)}
  115.     kCSPMSuspendMessage            = $0C;                            { power management suspend (TBD)}
  116.     kCSResetPhysicalMessage        = $0D;                            { physical reset is about to occur on this card}
  117.     kCSResetRequestMessage        = $0E;                            { physical reset has been requested by a client}
  118.     kCSResetCompleteMessage        = $0F;                            { ResetCard() background reset has completed}
  119.     kCSBatteryDeadMessage        = $10;                            { battery is no longer useable, data will be lost}
  120.     kCSBatteryLowMessage        = $11;                            { battery is weak and should be replaced}
  121.     kCSWriteProtectMessage        = $12;                            { card is now write protected}
  122.     kCSWriteEnabledMessage        = $13;                            { card is now write enabled}
  123.     kCSClientInfoMessage        = $14;                            { client is to return client information}
  124.     kCSSSUpdatedMessage            = $15;                            { AddSocketServices/ReplaceSocket services has changed SS support}
  125.     kCSFunctionInterruptMessage    = $16;                            { card function interrupt}
  126.     kCSAccessErrorMessage        = $17;                            { client bus errored on access to socket}
  127.     kCSCardUnconfiguredMessage    = $18;                            { a CARD_READY was delivered to all clients and no client }
  128. {    requested a configuration for the socket}
  129.     kCSStatusChangedMessage        = $19;                            { status change for cards in I/O mode}
  130.  
  131. {
  132.     The following is a mapping of the PCMCIA name space to the Macintosh name space.
  133.     These two enum lists will be removed and given to developers as a separate file.
  134. }
  135.     SUCCESS                        = noErr;
  136.     BAD_ADAPTER                    = kCSBadAdapterErr;
  137.     BAD_ATTRIBUTE                = kCSBadAttributeErr;
  138.     BAD_BASE                    = kCSBadBaseErr;
  139.     BAD_EDC                        = kCSBadEDCErr;
  140.     BAD_IRQ                        = kCSBadIRQErr;
  141.     BAD_OFFSET                    = kCSBadOffsetErr;
  142.     BAD_PAGE                    = kCSBadPageErr;
  143.     BAD_SIZE                    = kCSBadSizeErr;
  144.     BAD_SOCKET                    = kCSBadSocketErr;
  145.     BAD_TYPE                    = kCSBadTypeErr;
  146.     BAD_VCC                        = kCSBadVccErr;
  147.     BAD_VPP                        = kCSBadVppErr;
  148.     BAD_WINDOW                    = kCSBadWindowErr;
  149.     BAD_ARG_LENGTH                = kCSBadArgLengthErr;
  150.     BAD_ARGS                    = kCSBadArgsErr;
  151.     BAD_HANDLE                    = kCSBadHandleErr;
  152.     BAD_CIS                        = kCSBadCISErr;
  153.     BAD_SPEED                    = kCSBadSpeedErr;
  154.     READ_FAILURE                = kCSReadFailureErr;
  155.     WRITE_FAILURE                = kCSWriteFailureErr;
  156.     GENERAL_FAILURE                = kCSGeneralFailureErr;
  157.     NO_CARD                        = kCSNoCardErr;
  158.     UNSUPPORTED_FUNCTION        = kCSUnsupportedFunctionErr;
  159.     UNSUPPORTED_MODE            = kCSUnsupportedModeErr;
  160.     BUSY                        = kCSBusyErr;
  161.     WRITE_PROTECTED                = kCSWriteProtectedErr;
  162.     CONFIGURATION_LOCKED        = kCSConfigurationLockedErr;
  163.     IN_USE                        = kCSInUseErr;
  164.     NO_MORE_ITEMS                = kCSNoMoreItemsErr;
  165.     OUT_OF_RESOURCE                = kCSOutOfResourceErr;
  166.  
  167. {    messages sent to client's event handler}
  168.     NULL_MESSAGE                = kCSNullMessage;
  169.     CARD_INSERTION                = kCSCardInsertionMessage;
  170.     CARD_REMOVAL                = kCSCardRemovalMessage;
  171.     CARD_LOCK                    = kCSCardLockMessage;
  172.     CARD_UNLOCK                    = kCSCardUnlockMessage;
  173.     CARD_READY                    = kCSCardReadyMessage;
  174.     CARD_RESET                    = kCSCardResetMessage;
  175.     INSERTION_REQUEST            = kCSInsertionRequestMessage;
  176.     INSERTION_COMPLETE            = kCSInsertionCompleteMessage;
  177.     EJECTION_REQUEST            = kCSEjectionRequestMessage;
  178.     EJECTION_FAILED                = kCSEjectionFailedMessage;
  179.     PM_RESUME                    = kCSPMResumeMessage;
  180.     PM_SUSPEND                    = kCSPMSuspendMessage;
  181.     RESET_PHYSICAL                = kCSResetPhysicalMessage;
  182.     RESET_REQUEST                = kCSResetRequestMessage;
  183.     RESET_COMPLETE                = kCSResetCompleteMessage;
  184.     BATTERY_DEAD                = kCSBatteryDeadMessage;
  185.     BATTERY_LOW                    = kCSBatteryLowMessage;
  186.     WRITE_PROTECT                = kCSWriteProtectMessage;
  187.     WRITE_ENABLED                = kCSWriteEnabledMessage;
  188.     CLIENT_INFO                    = kCSClientInfoMessage;
  189.     SS_UPDATED                    = kCSSSUpdatedMessage;
  190.     FUNCTION_INTERRUPT            = kCSFunctionInterruptMessage;
  191.     ACCESS_ERROR                = kCSAccessErrorMessage;
  192.     CARD_UNCONFIGURED            = kCSCardUnconfiguredMessage;
  193.     STATUS_CHANGED                = kCSStatusChangedMessage;
  194.  
  195. {----------------        CSAccessConfigurationRegister    ----------------}
  196.  
  197. TYPE
  198.     AccessConfigurationRegisterPB = RECORD
  199.         socket:                    UInt16;                                    {  -> global socket number}
  200.         action:                    SInt8; (* UInt8 *)                        {  -> read/write}
  201.         offset:                    SInt8; (* UInt8 *)                        {  -> offset from config register base}
  202.         value:                    SInt8; (* UInt8 *)                        { <-> value to read/write}
  203.         padding:                ARRAY [0..0] OF SInt8; (* UInt8 *)        { }
  204.     END;
  205.  
  206. {    ‘action’ field values}
  207.  
  208. CONST
  209.     kCSReadConfigRegister        = $00;
  210.     kCSWriteConfigRegister        = $01;
  211.  
  212. {----------------        CSGetCardServicesInfo            ----------------}
  213.  
  214. TYPE
  215.     GetCardServicesInfoPB = RECORD
  216.         signature:                ARRAY [0..1] OF SInt8; (* UInt8 *)        { <-  two ascii chars 'CS'}
  217.         count:                    UInt16;                                    { <-  total number of sockets installed}
  218.         revision:                UInt16;                                    { <-  BCD}
  219.         csLevel:                UInt16;                                    { <-  BCD}
  220.         reserved:                UInt16;                                    {  -> zero}
  221.         vStrLen:                UInt16;                                    { <-> in: client's buffer size, out: vendor string length}
  222.         vendorString:            ^UInt8;                                    { <-> in: pointer to buffer to hold CS vendor string (zero-terminated)}
  223.         {      out: CS vendor string copied to buffer}
  224.     END;
  225.  
  226. {----------------        CSGetClientInfo                    ----------------}
  227.     ClientInfoParam = RECORD
  228.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  229.         attributes:                UInt16;                                    { <-> subfunction + bitmapped client attributes}
  230.         revision:                UInt16;                                    { <-  BCD value of client's revision}
  231.         csLevel:                UInt16;                                    { <-  BCD value of CS release}
  232.         revDate:                UInt16;                                    { <-  revision date: y[15-9], m[8-5], d[4-0]}
  233.         nameLen:                SInt16;                                    { <-> in: max length of client name string, out: actual length}
  234.         vStringLen:                SInt16;                                    { <-> in: max length of vendor string, out: actual length}
  235.         nameString:                ^UInt8;                                    { <-  pointer to client name string (zero-terminated)}
  236.         vendorString:            ^UInt8;                                    { <-  pointer to vendor string (zero-terminated)}
  237.     END;
  238.  
  239. { upper byte of attributes is kCSCardNameSubfunction,}
  240. {                               kCSCardTypeSubfunction,}
  241. {                               kCSHelpStringSubfunction}
  242.     AlternateTextStringParam = RECORD
  243.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  244.         attributes:                UInt16;                                    { <-> subfunction + bitmapped client attributes}
  245.         socket:                    UInt16;                                    {  -> logical socket number}
  246.         reserved:                UInt16;                                    {  -> zero}
  247.         length:                    SInt16;                                    { <-> in: max length of string, out: actual length}
  248.         text:                    ^UInt8;                                    { <-  pointer to string (zero-terminated)}
  249.     END;
  250.  
  251. { upper byte of attributes is kCSCardIconSubfunction}
  252.     AlternateCardIconParam = RECORD
  253.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  254.         attributes:                UInt16;                                    { <-> subfunction + bitmapped client attributes}
  255.         socket:                    UInt16;                                    {  -> logical socket number}
  256.         iconSuite:                Handle;                                    { <-  handle to icon suite containing all icons}
  257.     END;
  258.  
  259. { upper byte of attributes is kCSActionProcSubfunction}
  260.     CustomActionProcParam = RECORD
  261.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  262.         attributes:                UInt16;                                    { <-> subfunction + bitmapped client attributes}
  263.         socket:                    UInt16;                                    {  -> logical socket number}
  264.     END;
  265.  
  266.     GetClientInfoPB = RECORD
  267.         CASE INTEGER OF
  268.         0: (
  269.             clientInfo:                    ClientInfoParam;
  270.            );
  271.         1: (
  272.             alternateTextString:        AlternateTextStringParam;
  273.            );
  274.         2: (
  275.             alternateIcon:                AlternateCardIconParam;
  276.            );
  277.         3: (
  278.             customActionProc:            CustomActionProcParam;
  279.            );
  280.  
  281.     END;
  282.  
  283. {    ‘attributes’ field values}
  284.  
  285. CONST
  286.     kCSMemoryClient                = $0001;
  287.     kCSIOClient                    = $0004;
  288.     kCSClientTypeMask            = $0007;
  289.     kCSShareableCardInsertEvents = $0008;
  290.     kCSExclusiveCardInsertEvents = $0010;
  291.     kCSInfoSubfunctionMask        = $FF00;
  292.     kCSClientInfoSubfunction    = $0000;
  293.     kCSCardNameSubfunction        = $8000;
  294.     kCSCardTypeSubfunction        = $8100;
  295.     kCSHelpStringSubfunction    = $8200;
  296.     kCSCardIconSubfunction        = $8300;
  297.     kCSActionProcSubfunction    = $8400;
  298.  
  299. {----------------        CSGetConfigurationInfo            ----------------}
  300. {----------------        CSModifyConfiguration            ----------------}
  301. {----------------        CSRequestConfiguration            ----------------}
  302.  
  303. TYPE
  304.     GetModRequestConfigInfoPB = RECORD
  305.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  306.         socket:                    UInt16;                                    {  -> logical socket number}
  307.         attributes:                UInt16;                                    { <-> bitmap of configuration attributes}
  308.         vcc:                    SInt8; (* UInt8 *)                        { <-> Vcc setting}
  309.         vpp1:                    SInt8; (* UInt8 *)                        { <-> Vpp1 setting}
  310.         vpp2:                    SInt8; (* UInt8 *)                        { <-> Vpp2 setting}
  311.         intType:                SInt8; (* UInt8 *)                        { <-> interface type (memory or memory+I/O)}
  312.         configBase:                UInt32;                                    { <-> card base address of configuration registers}
  313.         status:                    SInt8; (* UInt8 *)                        { <-> card status register setting, if present}
  314.         pin:                    SInt8; (* UInt8 *)                        { <-> card pin register setting, if present}
  315.         copy:                    SInt8; (* UInt8 *)                        { <-> card socket/copy register setting, if present}
  316.         configIndex:            SInt8; (* UInt8 *)                        { <-> card option register setting, if present}
  317.         present:                SInt8; (* UInt8 *)                        { <-> bitmap of which configuration registers are present}
  318.         firstDevType:            SInt8; (* UInt8 *)                        { <-  from DeviceID tuple}
  319.         funcCode:                SInt8; (* UInt8 *)                        { <-  from FuncID tuple}
  320.         sysInitMask:            SInt8; (* UInt8 *)                        { <-  from FuncID tuple}
  321.         manufCode:                UInt16;                                    { <-  from ManufacturerID tuple}
  322.         manufInfo:                UInt16;                                    { <-  from ManufacturerID tuple}
  323.         cardValues:                SInt8; (* UInt8 *)                        { <-  valid card register values}
  324.         padding:                ARRAY [0..0] OF SInt8; (* UInt8 *)        { }
  325.     END;
  326.  
  327. {    ‘attributes’ field values}
  328.  
  329. CONST
  330.     kCSExclusivelyUsed            = $0001;
  331.     kCSEnableIREQs                = $0002;
  332.     kCSVccChangeValid            = $0004;
  333.     kCSVpp1ChangeValid            = $0008;
  334.     kCSVpp2ChangeValid            = $0010;
  335.     kCSValidClient                = $0020;
  336.     kCSSleepPower                = $0040;                        { request that power be applied to socket during Sleep}
  337.     kCSLockSocket                = $0080;
  338.     kCSTurnOnInUse                = $0100;
  339.  
  340. {    ‘intType’ field values}
  341.     kCSMemoryInterface            = $01;
  342.     kCSMemory_And_IO_Interface    = $02;
  343.  
  344. {    ‘present’ field values}
  345.     kCSOptionRegisterPresent    = $01;
  346.     kCSStatusRegisterPresent    = $02;
  347.     kCSPinReplacementRegisterPresent = $04;
  348.     kCSCopyRegisterPresent        = $08;
  349.  
  350. {    ‘cardValues’ field values}
  351.     kCSOptionValueValid            = $01;
  352.     kCSStatusValueValid            = $02;
  353.     kCSPinReplacementValueValid    = $04;
  354.     kCSCopyValueValid            = $08;
  355.  
  356. {----------------        CSGetClientEventMask            ----------------}
  357. {----------------        CSSetClientEventMask            ----------------}
  358.  
  359. TYPE
  360.     GetSetClientEventMaskPB = RECORD
  361.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  362.         attributes:                UInt16;                                    { <-> bitmap of attributes}
  363.         eventMask:                UInt16;                                    { <-> bitmap of events to be passed to client for this socket}
  364.         socket:                    UInt16;                                    {  -> logical socket number}
  365.     END;
  366.  
  367. {    ‘attributes’ field values}
  368.  
  369. CONST
  370.     kCSEventMaskThisSocketOnly    = $0001;
  371.  
  372. {    ‘eventMask’ field values}
  373.     kCSWriteProtectEvent        = $0001;
  374.     kCSCardLockChangeEvent        = $0002;
  375.     kCSEjectRequestEvent        = $0004;
  376.     kCSInsertRequestEvent        = $0008;
  377.     kCSBatteryDeadEvent            = $0010;
  378.     kCSBatteryLowEvent            = $0020;
  379.     kCSReadyChangeEvent            = $0040;
  380.     kCSCardDetectChangeEvent    = $0080;
  381.     kCSPMChangeEvent            = $0100;
  382.     kCSResetEvent                = $0200;
  383.     kCSSSUpdateEvent            = $0400;
  384.     kCSFunctionInterrupt        = $0800;
  385.     kCSAllEvents                = $FFFF;
  386.  
  387. {----------------        CSGetFirstClient                ----------------}
  388. {----------------        CSGetNextClient                    ----------------}
  389.  
  390. TYPE
  391.     GetClientPB = RECORD
  392.         clientHandle:            UInt32;                                    { <-  clientHandle for this client}
  393.         socket:                    UInt16;                                    {  -> logical socket number}
  394.         attributes:                UInt16;                                    {  -> bitmap of attributes}
  395.     END;
  396.  
  397. {    ‘attributes’ field values}
  398.  
  399. CONST
  400.     kCSClientsForAllSockets        = $0000;
  401.     kCSClientsThisSocketOnly    = $0001;
  402.  
  403. {----------------        CSGetFirstTuple                    ----------------}
  404. {----------------        CSGetNextTuple                    ----------------}
  405. {----------------        CSGetTupleData                    ----------------}
  406.  
  407. TYPE
  408.     GetTuplePB = RECORD
  409.         socket:                    UInt16;                                    {  -> logical socket number}
  410.         attributes:                UInt16;                                    {  -> bitmap of attributes}
  411.         desiredTuple:            SInt8; (* UInt8 *)                        {  -> desired tuple code value, or $FF for all}
  412.         tupleOffset:            SInt8; (* UInt8 *)                        {  -> offset into tuple from link byte}
  413.         flags:                    UInt16;                                    { <-> internal use}
  414.         linkOffset:                UInt32;                                    { <-> internal use}
  415.         cisOffset:                UInt32;                                    { <-> internal use}
  416.         CASE INTEGER OF
  417.         0: (
  418.             tupleCode:                    SInt8; (* UInt8 *)                    { <-  tuple code found}
  419.             tupleLink:                    SInt8; (* UInt8 *)                    { <-  link value for tuple found}
  420.            );
  421.         1: (
  422.             tupleDataMax:                UInt16;                                {  -> maximum size of tuple data area}
  423.             tupleDataLen:                UInt16;                                { <-  number of bytes in tuple body}
  424.             tupleData:                    TupleBody;                            { <-  tuple data}
  425.            );
  426.  
  427.     END;
  428.  
  429. {    ‘attributes’ field values}
  430.  
  431. CONST
  432.     kCSReturnLinkTuples            = $0001;
  433.  
  434. {----------------        CSRequestSocketMask                ----------------}
  435. {----------------        CSReleaseSocketMask                ----------------}
  436.  
  437. TYPE
  438.     ReqRelSocketMaskPB = RECORD
  439.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  440.         socket:                    UInt16;                                    {  -> logical socket}
  441.         eventMask:                UInt16;                                    {  -> bitmap of events to be passed to client for this socket}
  442.     END;
  443.  
  444. {    ‘eventMask’ field values (see above for Get/SetClientEventMask}
  445. {----------------        CSGetStatus                        ----------------}
  446.     GetStatusPB = RECORD
  447.         socket:                    UInt16;                                    {  -> logical socket number}
  448.         cardState:                UInt16;                                    { <-  current state of installed card}
  449.         socketState:            UInt16;                                    { <-  current state of the socket}
  450.     END;
  451.  
  452. {    ‘cardState’ field values}
  453.  
  454. CONST
  455.     kCSWriteProtected            = $0001;
  456.     kCSCardLocked                = $0002;
  457.     kCSEjectRequest                = $0004;
  458.     kCSInsertRequest            = $0008;
  459.     kCSBatteryDead                = $0010;
  460.     kCSBatteryLow                = $0020;
  461.     kCSReady                    = $0040;
  462.     kCSCardDetected                = $0080;
  463.  
  464. {    ‘socketState’ field values}
  465.     kCSWriteProtectChanged        = $0001;
  466.     kCSCardLockChanged            = $0002;
  467.     kCSEjectRequestPending        = $0004;
  468.     kCSInsertRequestPending        = $0008;
  469.     kCSBatteryDeadChanged        = $0010;
  470.     kCSBatteryLowChanged        = $0020;
  471.     kCSReadyChanged                = $0040;
  472.     kCSCardDetectChanged        = $0080;
  473.  
  474. {----------------        CSModifyWindow                    ----------------}
  475. {----------------        CSReleaseWindow                    ----------------}
  476. {----------------        CSRequestWindow                    ----------------}
  477.  
  478. TYPE
  479.     ReqModRelWindowPB = RECORD
  480.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  481.         windowHandle:            UInt32;                                    { <-> window descriptor}
  482.         socket:                    UInt16;                                    {  -> logical socket number}
  483.         attributes:                UInt16;                                    {  -> window attributes (bitmap)}
  484.         base:                    UInt32;                                    { <-> system base address}
  485.         size:                    UInt32;                                    { <-> memory window size}
  486.         accessSpeed:            SInt8; (* UInt8 *)                        {  -> window access speed (bitmap)}
  487.         {        (not applicable for I/O mode)}
  488.         padding:                ARRAY [0..0] OF SInt8; (* UInt8 *)        { }
  489.     END;
  490.  
  491. {    ‘attributes’ field values}
  492.  
  493. CONST
  494.     kCSMemoryWindow                = $0001;
  495.     kCSIOWindow                    = $0002;
  496.     kCSAttributeWindow            = $0004;                        { not normally used by Card Services clients}
  497.     kCSWindowTypeMask            = $0007;
  498.     kCSEnableWindow                = $0008;
  499.     kCSAccessSpeedValid            = $0010;
  500.     kCSLittleEndian                = $0020;                        { configure socket for little endianess}
  501.     kCS16BitDataPath            = $0040;                        {}
  502.     kCSWindowPaged                = $0080;                        { }
  503.     kCSWindowShared                = $0100;                        {}
  504.     kCSWindowFirstShared        = $0200;                        { }
  505.     kCSWindowProgrammable        = $0400;                        { }
  506.  
  507. {    ‘accessSpeed’ field values}
  508.     kCSDeviceSpeedCodeMask        = $07;
  509.     kCSSpeedExponentMask        = $07;
  510.     kCSSpeedMantissaMask        = $78;
  511.     kCSUseWait                    = $80;
  512.     kCSAccessSpeed250nsec        = $01;
  513.     kCSAccessSpeed200nsec        = $02;
  514.     kCSAccessSpeed150nsec        = $03;
  515.     kCSAccessSpeed100nsec        = $04;
  516.     kCSExtAccSpeedMant1pt0        = $01;
  517.     kCSExtAccSpeedMant1pt2        = $02;
  518.     kCSExtAccSpeedMant1pt3        = $03;
  519.     kCSExtAccSpeedMant1pt5        = $04;
  520.     kCSExtAccSpeedMant2pt0        = $05;
  521.     kCSExtAccSpeedMant2pt5        = $06;
  522.     kCSExtAccSpeedMant3pt0        = $07;
  523.     kCSExtAccSpeedMant3pt5        = $08;
  524.     kCSExtAccSpeedMant4pt0        = $09;
  525.     kCSExtAccSpeedMant4pt5        = $0A;
  526.     kCSExtAccSpeedMant5pt0        = $0B;
  527.     kCSExtAccSpeedMant5pt5        = $0C;
  528.     kCSExtAccSpeedMant6pt0        = $0D;
  529.     kCSExtAccSpeedMant7pt0        = $0E;
  530.     kCSExtAccSpeedMant8pt0        = $0F;
  531.     kCSExtAccSpeedExp1ns        = $00;
  532.     kCSExtAccSpeedExp10ns        = $01;
  533.     kCSExtAccSpeedExp100ns        = $02;
  534.     kCSExtAccSpeedExp1us        = $03;
  535.     kCSExtAccSpeedExp10us        = $04;
  536.     kCSExtAccSpeedExp100us        = $05;
  537.     kCSExtAccSpeedExp1ms        = $06;
  538.     kCSExtAccSpeedExp10ms        = $07;
  539.  
  540. {----------------        CSRegisterClient                ----------------}
  541. {----------------        CSDeregisterClient                ----------------}
  542.  
  543. TYPE
  544.     ClientCallbackPB = RECORD
  545.         message:                UInt16;                                    {  -> which event this is}
  546.         socket:                    UInt16;                                    {  -> logical socket number}
  547.         info:                    UInt16;                                    {  -> function-specific}
  548.         misc:                    UInt16;                                    {  -> function-specific}
  549.         reserved:                Ptr;                                    {  -> pointer to MTD request block}
  550.         buffer:                    Ptr;                                    {  -> function-specific}
  551.         clientData:                Ptr;                                    {  -> pointer to client's data (from RegisterClient)}
  552.     END;
  553.  
  554.     ClientCallbackPBPtr = ^ClientCallbackPB;
  555.  
  556.     PCCardCSClientProcPtr = ProcPtr;  { FUNCTION PCCardCSClient(ccPBPtr: ClientCallbackPBPtr): UInt16; }
  557.     PCCardCSClientUPP = UniversalProcPtr;
  558.  
  559. CONST
  560.     uppPCCardCSClientProcInfo = $000000E0; { FUNCTION (4 byte param): 2 byte result; }
  561.  
  562. FUNCTION NewPCCardCSClientProc(userRoutine: PCCardCSClientProcPtr): PCCardCSClientUPP;
  563.     {$IFC NOT GENERATINGCFM }
  564.     INLINE $2E9F;
  565.     {$ENDC}
  566.  
  567. FUNCTION CallPCCardCSClientProc(ccPBPtr: ClientCallbackPBPtr; userRoutine: PCCardCSClientUPP): UInt16;
  568.     {$IFC NOT GENERATINGCFM}
  569.     INLINE $205F, $4E90;
  570.     {$ENDC}
  571.  
  572. TYPE
  573.     RegisterClientPB = RECORD
  574.         clientHandle:            UInt32;                                    { <-  client descriptor}
  575.         clientEntry:            PCCardCSClientUPP;                        {  -> universal procPtr to client's event handler}
  576.         attributes:                UInt16;                                    {  -> bitmap of client attributes}
  577.         eventMask:                UInt16;                                    {  -> bitmap of events to notify client}
  578.         clientData:                Ptr;                                    {  -> pointer to client's data}
  579.         version:                UInt16;                                    {  -> Card Services version this client expects}
  580.     END;
  581.  
  582. {    ‘attributes’ field values (see GetClientInfo)}
  583. {    kCSMemoryClient                    = 0x0001,}
  584. {    kCSIOClient                        = 0x0004,}
  585. {    kCSShareableCardInsertEvents    = 0x0008,}
  586. {    kCSExclusiveCardInsertEvents    = 0x0010}
  587. {----------------        CSReleaseConfiguration            ----------------}
  588.     ReleaseConfigurationPB = RECORD
  589.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  590.         socket:                    UInt16;                                    {  -> }
  591.     END;
  592.  
  593. {----------------        CSResetCard                        ----------------}
  594.     ResetCardPB = RECORD
  595.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  596.         socket:                    UInt16;                                    {  -> }
  597.         attributes:                UInt16;                                    {  -> xxx}
  598.     END;
  599.  
  600. {----------------        CSValidateCIS                    ----------------}
  601.     ValidateCISPB = RECORD
  602.         socket:                    UInt16;                                    {  -> }
  603.         chains:                    UInt16;                                    {  -> whether link/null tuples should be included}
  604.     END;
  605.  
  606. {----------------        CSVendorSpecific                ----------------}
  607.     VendorSpecificPB = RECORD
  608.         clientHandle:            UInt32;                                    {  -> clientHandle returned by RegisterClient}
  609.         vsCode:                    UInt16;
  610.         socket:                    UInt16;
  611.         dataLen:                UInt32;                                    {  -> length of buffer pointed to by vsDataPtr}
  612.         vsDataPtr:                ^UInt8;                                    {  -> Card Services version this client expects}
  613.     END;
  614.  
  615. {    ‘vsCode’ field values}
  616.  
  617. CONST
  618.     vsAppleReserved                = $0000;
  619.     vsEjectCard                    = $0001;
  620.     vsGetCardInfo                = $0002;
  621.     vsEnableSocketEvents        = $0003;
  622.     vsGetCardLocationIcon        = $0004;
  623.     vsGetCardLocationText        = $0005;
  624.     vsGetAdapterInfo            = $0006;
  625.  
  626. {///////////////////////////////////////////////////////////////////////////////////////}
  627. {}
  628. {    GetAdapterInfo parameter block (vendor-specific call #6)}
  629.  
  630. TYPE
  631.     GetAdapterInfoPB = RECORD
  632.         attributes:                UInt32;                                    { <-  capabilties of socket's adapter}
  633.         revision:                UInt16;                                    { <-  id of adapter}
  634.         reserved:                UInt16;                                    { }
  635.         numVoltEntries:            UInt16;                                    { <-  number of valid voltage values}
  636.         voltages:                ^UInt8;                                    { <-> array of BCD voltage values}
  637.     END;
  638.  
  639. {    ‘attributes’ field values}
  640.  
  641. CONST
  642.     kCSLevelModeInterrupts        = $00000001;
  643.     kCSPulseModeInterrupts        = $00000002;
  644.     kCSProgrammableWindowAddr    = $00000004;
  645.     kCSProgrammableWindowSize    = $00000008;
  646.     kCSSocketSleepPower            = $00000010;
  647.     kCSSoftwareEject            = $00000020;
  648.     kCSLockableSocket            = $00000040;
  649.     kCSInUseIndicator            = $00000080;
  650.  
  651. {///////////////////////////////////////////////////////////////////////////////////////}
  652. {}
  653. {    GetCardInfo parameter block (vendor-specific call #2)}
  654.  
  655. TYPE
  656.     GetCardInfoPB = RECORD
  657.         cardType:                SInt8; (* UInt8 *)                        { <-  type of card in this socket (defined at top of file)}
  658.         subType:                SInt8; (* UInt8 *)                        { <-  more detailed card type (defined at top of file)}
  659.         reserved:                UInt16;                                    { <-> reserved (should be set to zero)}
  660.         cardNameLen:            UInt16;                                    {  -> maximum length of card name to be returned}
  661.         vendorNameLen:            UInt16;                                    {  -> maximum length of vendor name to be returned}
  662.         cardName:                ^UInt8;                                    {  -> pointer to card name string (read from CIS), or nil}
  663.         vendorName:                ^UInt8;                                    {  -> pointer to vendor name string (read from CIS), or nil}
  664.     END;
  665.  
  666. {    GetCardInfo card types}
  667.  
  668. CONST
  669.     kCSUnknownCardType            = 0;
  670.     kCSMultiFunctionCardType    = 1;
  671.     kCSMemoryCardType            = 2;
  672.     kCSSerialPortCardType        = 3;
  673.     kCSSerialOnlyType            = 0;
  674.     kCSDataModemType            = 1;
  675.     kCSFaxModemType                = 2;
  676.     kCSFaxAndDataModemMask        = 0+(kCSDataModemType + kCSFaxModemType);
  677.     kCSVoiceEncodingType        = 4;
  678.     kCSParallelPortCardType        = 4;
  679.     kCSFixedDiskCardType        = 5;
  680.     kCSUnknownFixedDiskType        = 0;
  681.     kCSATAInterface                = 1;
  682.     kCSRotatingDevice            = 0+(0 * (2**(7)));
  683.     kCSSiliconDevice            = 0+(1 * (2**(7)));
  684.     kCSVideoAdaptorCardType        = 6;
  685.     kCSNetworkAdaptorCardType    = 7;
  686.     kCSAIMSCardType                = 8;
  687.     kCSNumCardTypes                = 9;
  688.  
  689.  
  690. FUNCTION CSVendorSpecific(VAR pb: VendorSpecificPB): OSErr;
  691.     {$IFC NOT GENERATINGCFM}
  692.     INLINE $7000, $AAF0;
  693.     {$ENDC}
  694. FUNCTION CSRegisterClient(VAR pb: RegisterClientPB): OSErr;
  695.     {$IFC NOT GENERATINGCFM}
  696.     INLINE $7001, $AAF0;
  697.     {$ENDC}
  698. FUNCTION CSDeregisterClient(VAR pb: RegisterClientPB): OSErr;
  699.     {$IFC NOT GENERATINGCFM}
  700.     INLINE $7002, $AAF0;
  701.     {$ENDC}
  702. FUNCTION CSGetFirstTuple(VAR pb: GetTuplePB): OSErr;
  703.     {$IFC NOT GENERATINGCFM}
  704.     INLINE $7003, $AAF0;
  705.     {$ENDC}
  706. FUNCTION CSGetNextTuple(VAR pb: GetTuplePB): OSErr;
  707.     {$IFC NOT GENERATINGCFM}
  708.     INLINE $7004, $AAF0;
  709.     {$ENDC}
  710. FUNCTION CSGetTupleData(VAR pb: GetTuplePB): OSErr;
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $7005, $AAF0;
  713.     {$ENDC}
  714. FUNCTION CSGetConfigurationInfo(VAR pb: GetModRequestConfigInfoPB): OSErr;
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $7006, $AAF0;
  717.     {$ENDC}
  718. FUNCTION CSGetCardServicesInfo(VAR pb: GetCardServicesInfoPB): OSErr;
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $7007, $AAF0;
  721.     {$ENDC}
  722. FUNCTION CSGetStatus(VAR pb: GetStatusPB): OSErr;
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $7008, $AAF0;
  725.     {$ENDC}
  726. FUNCTION CSValidateCIS(VAR pb: ValidateCISPB): OSErr;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $7009, $AAF0;
  729.     {$ENDC}
  730. FUNCTION CSGetFirstClient(VAR pb: GetClientPB): OSErr;
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $700F, $AAF0;
  733.     {$ENDC}
  734. FUNCTION CSGetNextClient(VAR pb: GetClientPB): OSErr;
  735.     {$IFC NOT GENERATINGCFM}
  736.     INLINE $7010, $AAF0;
  737.     {$ENDC}
  738. FUNCTION CSGetClientInfo(VAR pb: GetClientInfoPB): OSErr;
  739.     {$IFC NOT GENERATINGCFM}
  740.     INLINE $7011, $AAF0;
  741.     {$ENDC}
  742. FUNCTION CSResetCard(VAR pb: ResetCardPB): OSErr;
  743.     {$IFC NOT GENERATINGCFM}
  744.     INLINE $7012, $AAF0;
  745.     {$ENDC}
  746. FUNCTION CSRequestWindow(VAR pb: ReqModRelWindowPB): OSErr;
  747.     {$IFC NOT GENERATINGCFM}
  748.     INLINE $7013, $AAF0;
  749.     {$ENDC}
  750. FUNCTION CSModifyWindow(VAR pb: ReqModRelWindowPB): OSErr;
  751.     {$IFC NOT GENERATINGCFM}
  752.     INLINE $7014, $AAF0;
  753.     {$ENDC}
  754. FUNCTION CSReleaseWindow(VAR pb: ReqModRelWindowPB): OSErr;
  755.     {$IFC NOT GENERATINGCFM}
  756.     INLINE $7015, $AAF0;
  757.     {$ENDC}
  758. FUNCTION CSRequestConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  759.     {$IFC NOT GENERATINGCFM}
  760.     INLINE $701B, $AAF0;
  761.     {$ENDC}
  762. FUNCTION CSModifyConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  763.     {$IFC NOT GENERATINGCFM}
  764.     INLINE $701C, $AAF0;
  765.     {$ENDC}
  766. FUNCTION CSAccessConfigurationRegister(VAR pb: AccessConfigurationRegisterPB): OSErr;
  767.     {$IFC NOT GENERATINGCFM}
  768.     INLINE $701D, $AAF0;
  769.     {$ENDC}
  770. FUNCTION CSReleaseConfiguration(VAR pb: ReleaseConfigurationPB): OSErr;
  771.     {$IFC NOT GENERATINGCFM}
  772.     INLINE $701E, $AAF0;
  773.     {$ENDC}
  774. FUNCTION CSGetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  775.     {$IFC NOT GENERATINGCFM}
  776.     INLINE $701F, $AAF0;
  777.     {$ENDC}
  778. FUNCTION CSSetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  779.     {$IFC NOT GENERATINGCFM}
  780.     INLINE $7020, $AAF0;
  781.     {$ENDC}
  782. FUNCTION CSRequestSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  783.     {$IFC NOT GENERATINGCFM}
  784.     INLINE $7021, $AAF0;
  785.     {$ENDC}
  786. FUNCTION CSReleaseSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  787.     {$IFC NOT GENERATINGCFM}
  788.     INLINE $7022, $AAF0;
  789.     {$ENDC}
  790.  
  791. {$ALIGN RESET}
  792. {$POP}
  793.  
  794. {$SETC UsingIncludes := CardServicesIncludes}
  795.  
  796. {$ENDC} {__CARDSERVICES__}
  797.  
  798. {$IFC NOT UsingIncludes}
  799.  END.
  800. {$ENDC}
  801.